home *** CD-ROM | disk | FTP | other *** search
/ Mac Action 1996 January / mac-action-07.iso / mac / Sound ’n’ Vision / CD Strip 1.0b / CD Strip.c < prev    next >
Encoding:
Text File  |  1994-10-22  |  14.4 KB  |  534 lines  |  [TEXT/MMCC]
  1. //•    CD Strip by Chris De Salvo, ©1994
  2. //•    Based on an the framework of Debugger Strip by Glenn R. Howes
  3.  
  4. //•    ------------------------------    Includes
  5.  
  6. #include <A4Stuff.h>
  7. #include <Icons.h>
  8. #include <Folders.h>
  9. #include <ControlStrip.h>
  10.  
  11. //•    ------------------------------    Private Definitions
  12.  
  13. #define kBaseResID            256
  14. #define kMenuID                kBaseResID
  15. #define kIconSuite            kBaseResID + 1
  16. #define kCDInString            1
  17. #define kCDOutString        2
  18.  
  19. //•    Feature flags
  20. #define kWantMouseClicks    0x0001
  21. #define kDontAutoTrack        0x0002
  22. #define kHasCustomHelp        0x0004
  23. #define kKeepModuleLocked    0x0008
  24.  
  25. //•    ------------------------------    Private Constants
  26. //•    ------------------------------    Private Types
  27. //•    ------------------------------    Private Structs
  28.  
  29. typedef struct CDIndex
  30. {
  31.     char    numTracks;
  32.     char    minutes;
  33.     char    seconds;
  34.     char    frames;
  35.     short    strIndex;
  36. } CDIndex;
  37.  
  38. typedef struct MyGlobals
  39. {
  40.     Handle        iconSuite;            //•    Our module's icon
  41.     Boolean        driverInited;        //•    Have we successfully opened the CD-ROM driver
  42.     short        driverRef;            //•    The driver reference number
  43.     MenuHandle    trackMenu;            //•    Menu handle for our pop-up menu
  44.     Str255        cdInHelp;            //•    Help balloon text when cd is inserted
  45.     Str255        cdOutHelp;            //•    Help balloon text when no cd is inserted
  46.     FSSpec        prefsFile;            //•    Location of the 'CD Remote Programs' file
  47. } MyGlobals, *MyGlobalPtr, **MyGlobalHandle;
  48.  
  49. //•    ------------------------------    Private Variables
  50. //•    ------------------------------    Private Functions
  51.  
  52. static void DoCSDraw(MyGlobalHandle myGlobals, Rect *statusRect);
  53. static void DoCSClose(MyGlobalHandle myGlobals);
  54. static long DoCSInit(void);
  55. static void DoCSClick(MyGlobalHandle myGlobals, Rect *statusRect);
  56. static OSErr DoCSHelp(MyGlobalHandle myGlobals, Rect *statusRect);
  57.  
  58. static Boolean IsCDInserted(short driverRef);
  59. static short GetNumTracks(short driverRef);
  60. static void PlayTrackNum(int trackNum, short driverRef);
  61. static void ClearMenu(MenuHandle theMenu);
  62. static Boolean FindTitleIndex(MyGlobalHandle myGlobals);
  63. static char GetCurrentTrack(MyGlobalHandle myGlobals);
  64.  
  65. //•    ------------------------------    Public Functions
  66.  
  67. pascal long main (long message, long params, Rect *statusRect, GrafPtr statusPort);
  68.  
  69. //•    ------------------------------    Public Variables
  70.  
  71. //•    ------------------------------    main
  72.  
  73. pascal long
  74. main (long message, long params, Rect *statusRect, GrafPtr statusPort)
  75. {
  76. long    result = 0L;
  77. long    oldA4;
  78.  
  79.     oldA4 = SetCurrentA4();
  80.  
  81.     switch (message)
  82.     {
  83.         case sdevInitModule:
  84.             result = DoCSInit();
  85.             break;
  86.         
  87.         case sdevCloseModule:
  88.             DoCSClose((MyGlobalHandle) params);
  89.             break;
  90.         
  91.         case sdevFeatures:
  92.             result = kWantMouseClicks | kDontAutoTrack | kHasCustomHelp;
  93.             break;
  94.         
  95.         case sdevGetDisplayWidth:
  96.             result = 16L;            //•    Size of a small icon width
  97.             break;
  98.         
  99.         case sdevPeriodicTickle:
  100.             //•    This might eventually check for audio-play completion so that we can
  101.             //•    do looping.
  102.             break;
  103.         
  104.         case sdevDrawStatus:
  105.             DoCSDraw((MyGlobalHandle) params, statusRect);
  106.             break;
  107.         
  108.         case sdevMouseClick:
  109.             DoCSClick((MyGlobalHandle) params, statusRect);
  110.             break;
  111.         
  112.         case sdevSaveSettings:
  113.             break;
  114.         
  115.         case sdevShowBalloonHelp:
  116.             DoCSHelp((MyGlobalHandle) params, statusRect);
  117.             break;
  118.     }
  119.  
  120.     SetA4(oldA4);
  121.  
  122.     return (result);
  123. }
  124.  
  125. //•    ------------------------------    DoCSClick
  126.  
  127. static void
  128. DoCSClick(MyGlobalHandle myGlobals, Rect *moduleRect)
  129. {
  130. short    theTrack;
  131. OSErr    theErr;
  132. char    lockState;
  133. short    refNum;
  134. int        numTracks;
  135. int        loop;
  136. Str255    theString;
  137.  
  138.     lockState = HGetState((Handle) myGlobals);
  139.     HLock((Handle) myGlobals);
  140.     
  141.     //•    Try to open the CD-ROM driver.  The reason that I'm having it attempt this
  142.     //•    here instead of in the init section is because Control Strip could load before
  143.     //•    The CD-ROM driver extension.  Remember, extensions are loaded alphabetically and
  144.     //•    if you're running a third-party driver like DriveCD you'd load after Control Strip.
  145.     if (! (*myGlobals)->driverInited)
  146.     {
  147.         theErr = OpenDriver("\p.AppleCD", &refNum);
  148.         if (theErr)
  149.         {
  150.             HSetState((Handle) myGlobals, lockState);
  151.             return;
  152.         }
  153.  
  154.         (*myGlobals)->driverInited = TRUE;
  155.         (*myGlobals)->driverRef = refNum;
  156.     }
  157.  
  158.     //•    Find out how many tracks are on the CD and prepare the pop-up menu
  159.     numTracks = GetNumTracks((*myGlobals)->driverRef);
  160.     ClearMenu((*myGlobals)->trackMenu);
  161.  
  162.     //•    If no CD is inserted, then display the error message
  163.     if ((! numTracks) || (! IsCDInserted((*myGlobals)->driverRef)))
  164.     {
  165.         //•    Set the menu item to our error message and gray it out
  166.         SetItem((*myGlobals)->trackMenu, 1, "\pNo Audio CD Available");
  167.         DisableItem((*myGlobals)->trackMenu, 1);
  168.     }
  169.     //•    If track titles have been entered in CD Remote then use those entries and mark current track.
  170.     //•    Otherwise, just use the numbers of the tracks
  171.     else if (FindTitleIndex(myGlobals))
  172.         SetItemMark((*myGlobals)->trackMenu, GetCurrentTrack(myGlobals), '•');
  173.     else
  174.     {
  175.         //•    I'm just using the track number as menu entries for now until I figure
  176.         //•    out how to index into the 'CD Remote Programs' file for the track names.
  177.         NumToString(1L, theString);
  178.         SetItem((*myGlobals)->trackMenu, 1, theString);
  179.  
  180.         for (loop = 2; loop < numTracks + 1; loop++)
  181.         {
  182.             NumToString((long) loop, theString);
  183.             InsMenuItem((*myGlobals)->trackMenu, theString, loop - 1);
  184.         }
  185.     }
  186.  
  187.     //•    Put up the pop-up menu start tracking
  188.     theTrack = SBTrackPopupMenu(moduleRect, (*myGlobals)->trackMenu);
  189.  
  190.     //•    If there are tracks to play and the user picked one, play it.
  191.     if ((numTracks > 0) && theTrack)
  192.         PlayTrackNum(theTrack & 0xFF, (*myGlobals)->driverRef);
  193.  
  194.     //•    Turn item one back on if it was disabled
  195.     EnableItem((*myGlobals)->trackMenu, 1);
  196.     HSetState((Handle) myGlobals, lockState);
  197. }
  198.  
  199. //•    ------------------------------    DoCSInit
  200.  
  201. static long
  202. DoCSInit()
  203. {
  204. MyGlobalHandle    myH;
  205. Handle            tempHandle = 0L;
  206. OSErr            theErr;
  207. FSSpec            theFSSpec;
  208.  
  209.     myH = (MyGlobalHandle) NewHandleClear(sizeof (MyGlobals));
  210.     if (! myH)
  211.         return (-1L);
  212.  
  213.     //•    Get a detached handle to the icon suite
  214.     SBGetDetachIconSuite(&tempHandle, kIconSuite, 0x0000FF00);
  215.     (*myH)->iconSuite = tempHandle;
  216.  
  217.     (*myH)->driverInited = FALSE;
  218.  
  219.     //•    Get a handle to the menu and detach it
  220.     (*myH)->trackMenu = GetMenu(kMenuID);
  221.     if (! (*myH)->trackMenu)
  222.         return (-1L);
  223.         
  224.     DetachResource((Handle) (*myH)->trackMenu);
  225.  
  226.     //•    Get a handle to the balloon help strings, driver name and error message and detach them
  227.     GetIndString((*myH)->cdInHelp, kBaseResID, kCDInString);
  228.     GetIndString((*myH)->cdOutHelp, kBaseResID, kCDOutString);
  229.  
  230.     //•    Find the location of the Preferences Folder so we can look for programs
  231.     theErr = FindFolder(kOnSystemDisk, kPreferencesFolderType, FALSE, &theFSSpec.vRefNum, &theFSSpec.parID);
  232.     if (theErr)
  233.     {
  234.         //•    If we couldn't find the folder then fill in the FSSpec with bogus values
  235.         theFSSpec.vRefNum = -1;
  236.         theFSSpec.parID = -1;
  237.         theFSSpec.name[0] = 0;
  238.     }
  239.     else
  240.     {
  241.         //•    Complete the FSSpec
  242.         BlockMove("\pCD Remote Programs", &theFSSpec.name, 19);
  243.     }
  244.     
  245.     BlockMove(&theFSSpec, &(*myH)->prefsFile, sizeof (FSSpec));
  246.     
  247.     //•    If we made it here, we're successful.  Return our handle.
  248.     return ((long) myH);
  249. }
  250.  
  251. //•    ------------------------------    DoCSClose
  252.  
  253. static void
  254. DoCSClose(MyGlobalHandle myGlobals)
  255. {
  256.     //•    We've been asked to close up so free our memory
  257.     //•    We're not closing the CD-ROM driver because someone else is probably using it
  258.     if (myGlobals) 
  259.     {
  260.         if ((*myGlobals)->iconSuite)
  261.             DisposeIconSuite ((*myGlobals)->iconSuite, TRUE);
  262.  
  263.         DisposeHandle((Handle) myGlobals);
  264.     }
  265. }
  266.  
  267. //•    ------------------------------    DoCSDraw
  268.  
  269. static void
  270. DoCSDraw(MyGlobalHandle myGlobals, Rect *statusRect)
  271. {
  272.     //•    Just draw our icon in our space
  273.     if ((*myGlobals)->iconSuite)
  274.         PlotIconSuite(statusRect, atAbsoluteCenter, ttNone, (*myGlobals)->iconSuite);
  275. }
  276.  
  277. //•    ------------------------------    DoCSDraw
  278.  
  279. static OSErr
  280. DoCSHelp(MyGlobalHandle myGlobals, Rect *statusRect)
  281. {
  282.     //•    If we haven't been able to open the driver don't bother checking the drive
  283.     if (! (*myGlobals)->driverInited)
  284.         return (SBShowHelpString(statusRect, (*myGlobals)->cdOutHelp));
  285.     //•    If the driver is open, check the drive for a CD
  286.     else if (IsCDInserted((*myGlobals)->driverRef))
  287.         return (SBShowHelpString(statusRect, (*myGlobals)->cdInHelp));
  288.     //•    Yes, this is redundant, but it was quick
  289.     else
  290.         return (SBShowHelpString(statusRect, (*myGlobals)->cdOutHelp));
  291. }
  292.  
  293. //•    ------------------------------    IsCDInserted
  294.  
  295. static Boolean
  296. IsCDInserted(short driverRef)
  297. {
  298. ParamBlockRec    params;
  299. OSErr            theErr;
  300.     
  301.     //•    On return from a drive status call the csParam fields have the same info
  302.     //•    as the regular disk driver DrvSts structure.  The fourth byte in that
  303.     //•    structure is TRUE or FALSE depending on whether or not a disk is in the drive.
  304.  
  305.     params.cntrlParam.ioCompletion = nil;
  306.     params.cntrlParam.ioVRefNum = 1;
  307.     params.cntrlParam.ioCRefNum = driverRef;
  308.     params.cntrlParam.csCode = 8;                    //•    Drive Status
  309.     
  310.     theErr = PBStatus((ParmBlkPtr) ¶ms, FALSE);
  311.     if (theErr)
  312.         return (FALSE);
  313.     
  314.     return (params.cntrlParam.csParam[1] & 0xFF);
  315. }
  316.  
  317. //•    ------------------------------    GetNumTracks
  318.  
  319. static short
  320. GetNumTracks(short driverRef)
  321. {
  322. ParamBlockRec    params;
  323. OSErr            theErr;
  324. int                loop;
  325. char            lastTrack;
  326.     
  327.     params.cntrlParam.ioCompletion = nil;
  328.     params.cntrlParam.ioVRefNum = 1;
  329.     params.cntrlParam.ioCRefNum = driverRef;
  330.     params.cntrlParam.csCode = 100;                    //•    Read TOC
  331.     params.cntrlParam.csParam[0] = 1;                //•    Type 1 TOC lookup marker
  332.  
  333.     //•    CD-ROM driver ref says we should zero the rest of the fields out.  Probably don't
  334.     //•    but why takes chances?
  335.     for (loop = 1; loop < 11; loop++)
  336.         params.cntrlParam.csParam[loop] = 0;
  337.     
  338.     theErr = PBControl(¶ms, FALSE);
  339.     if (theErr)
  340.         return (0);
  341.  
  342.     lastTrack = params.cntrlParam.csParam[0] & 0xFF;
  343.  
  344.     //•    Return the number of tracks in decimal instead of BCD form.
  345.     return ((((lastTrack >> 4) & 0x0F) * 10) + (lastTrack & 0x0F));
  346. }
  347.  
  348. //•    ------------------------------    PlayTrackNum
  349.  
  350. static void
  351. PlayTrackNum(int trackNum, short driverRef)
  352. {
  353. ParamBlockRec    params;
  354. OSErr            theErr;
  355. int                loop;
  356.     
  357.     params.cntrlParam.ioCompletion = nil;
  358.     params.cntrlParam.ioVRefNum = 1;
  359.     params.cntrlParam.ioCRefNum = driverRef;
  360.     params.cntrlParam.csCode = 104;                    //•    Audio Play
  361.     params.cntrlParam.csParam[0] = 0x0002;            //•    Use a BCD Track Number
  362.     
  363.     //•    Params 1 and 2 are the 32-bit value (in BCD) of the track to play.
  364.     //•    Seems odd to me that they used 2 bytes for this since the highest legal
  365.     //•    track number you can have is 99.
  366.     params.cntrlParam.csParam[1] = 0x0000;
  367.     params.cntrlParam.csParam[2] = ((trackNum / 10) << 4) + (trackNum % 10);
  368.  
  369.     params.cntrlParam.csParam[3] = 0x0000;            //•    Indicate that this is a starting address
  370.     params.cntrlParam.csParam[4] = 0x0009;            //•    Play in normal stereo mode
  371.  
  372.     //•    Clear the rest of the params
  373.     for (loop = 5; loop < 11; loop++)
  374.         params.cntrlParam.csParam[loop] = 0;
  375.     
  376.     theErr = PBControl(¶ms, FALSE);
  377.     if (theErr)
  378.         SysBeep(3);
  379. }
  380.  
  381. //•    ------------------------------    ClearMenu
  382.  
  383. static void
  384. ClearMenu(MenuHandle theMenu)
  385. {
  386. short    numItems;
  387.  
  388.     //•    See how many items are currently in the menu
  389.     numItems = CountMItems(theMenu);
  390.     
  391.     //•    Remove all but one entry from the menu
  392.     while (--numItems)
  393.         DelMenuItem(theMenu, 1);
  394.     
  395.     //•    Clear the item mark if it was there
  396.     SetItemMark(theMenu, 1, 0x00);
  397. }
  398.  
  399. //•    ------------------------------    FindTitleIndex
  400.  
  401. static Boolean
  402. FindTitleIndex(MyGlobalHandle myGlobals)
  403. {
  404. ParamBlockRec    params;
  405. CDIndex            tempIndex;
  406. Handle            theHandle;
  407. int                loop;
  408. short            numEntries;
  409. OSErr            theErr;
  410. short            fileRef;
  411. Ptr                index;
  412. char            minutes, seconds, frames;
  413. short            tracks;
  414. short            strIndex = 0;
  415. Str255            tempString;
  416.  
  417.     //•    Attempt to open the CD Remote Programs file
  418.     fileRef = FSpOpenResFile(&(*myGlobals)->prefsFile, fsRdPerm);
  419.     if (fileRef == -1)
  420.         return (FALSE);
  421.         
  422.     //•    Load the Indx resource so we can check for entries
  423.     theHandle = GetResource('IndX', 128);
  424.     if (! theHandle)
  425.     {
  426.         FSClose(fileRef);
  427.         return (FALSE);
  428.     }
  429.  
  430.     //•    Get a pointer to the Index info and skip past the version number
  431.     index = *theHandle;
  432.     index += 2;
  433.     
  434.     //•    Find out how many entries there are in the catalog
  435.     numEntries = * ((short *) index);
  436.     if (numEntries == 0)
  437.     {
  438.         FSClose(fileRef);
  439.         return (FALSE);
  440.     }
  441.  
  442.     //•    Skip past the number of entries
  443.     index += 2;
  444.  
  445.     //•    Get the info for the currently mounted audio CD
  446.     params.cntrlParam.ioCompletion = nil;
  447.     params.cntrlParam.ioVRefNum = 1;
  448.     params.cntrlParam.ioCRefNum = (*myGlobals)->driverRef;
  449.     params.cntrlParam.csCode = 100;                    //•    Read TOC
  450.     params.cntrlParam.csParam[0] = 2;                //•    Type 2 TOC lookup marker
  451.  
  452.     //•    Clear unneeded fields
  453.     for (loop = 1; loop < 11; loop++)
  454.         params.cntrlParam.csParam[loop] = 0;
  455.     
  456.     //•    Call the CD driver to check the lead-out time of the final session
  457.     theErr = PBControl(¶ms, FALSE);
  458.     if (theErr)
  459.     {
  460.         ReleaseResource(theHandle);
  461.         FSClose(fileRef);
  462.         return (FALSE);
  463.     }
  464.  
  465.     //•    Extract catalog info
  466.     minutes = (params.cntrlParam.csParam[0] >> 8) & 0xFF;
  467.     seconds = params.cntrlParam.csParam[0] & 0xFF;
  468.     frames = (params.cntrlParam.csParam[1] >> 8) & 0xFF;
  469.     tracks = GetNumTracks((*myGlobals)->driverRef);
  470.  
  471.     //•    Loop through all the entries in the Indx resource and check for matches
  472.     for (loop = 0; loop < numEntries; loop++, index += sizeof (CDIndex))
  473.     {
  474.         BlockMove(index, &tempIndex, sizeof (CDIndex));
  475.         if ((tempIndex.numTracks == tracks)
  476.         &&    (tempIndex.minutes == minutes)
  477.         &&    (tempIndex.seconds == seconds)
  478.         &&    (tempIndex.frames == frames))
  479.             strIndex = tempIndex.strIndex;
  480.     }
  481.  
  482.     ReleaseResource(theHandle);
  483.  
  484.     if (! strIndex)
  485.         return (FALSE);
  486.  
  487.     //•    Get name of first song title.  String 1 is the name of the album so we get #2
  488.     GetIndString(tempString, strIndex, 2);
  489.     SetItem((*myGlobals)->trackMenu, 1, tempString);
  490.     EnableItem((*myGlobals)->trackMenu, 1);
  491.  
  492.     //•    Fill in the rest of the entries
  493.     for (loop = 3; loop < tracks + 2; loop++)
  494.     {
  495.         GetIndString(tempString, strIndex, loop);
  496.         InsMenuItem((*myGlobals)->trackMenu, tempString, loop - 2);
  497.         EnableItem((*myGlobals)->trackMenu, loop - 2);
  498.     }
  499.     
  500.     FSClose(fileRef);
  501.  
  502.     return (TRUE);
  503. }
  504.  
  505. //•    ------------------------------    GetCurrentTrack
  506.  
  507. static char
  508. GetCurrentTrack(MyGlobalHandle myGlobals)
  509. {
  510. ParamBlockRec    params;
  511. OSErr            theErr;
  512. int                loop;
  513. char            track;
  514.  
  515.     //•    Get the info for the current track
  516.     params.cntrlParam.ioCompletion = nil;
  517.     params.cntrlParam.ioVRefNum = 1;
  518.     params.cntrlParam.ioCRefNum = (*myGlobals)->driverRef;
  519.     params.cntrlParam.csCode = 101;                    //•    Read Q Subcodes for current track
  520.  
  521.     //•    Clear unneeded fields
  522.     for (loop = 0; loop < 11; loop++)
  523.         params.cntrlParam.csParam[loop] = 0;
  524.     
  525.     //•    Call the CD driver to check the Q codes for the current track
  526.     theErr = PBControl(¶ms, FALSE);
  527.     if (theErr)
  528.         return (0xFF);
  529.  
  530.     track = params.cntrlParam.csParam[0] & 0xFF;
  531.     
  532.     //•    Convert to decimal (from BCD) and return
  533.     return (((track >> 4) * 10) + (track & 0x0F));
  534. }